define('ace/mode/scss_highlight_rules', ['require', 'exports', 'module', 'ace/lib/oop', 'ace/lib/lang', 'ace/mode/text_highlight_rules'], function(require, exports, module) {
  'use strict'

  var oop = require('../lib/oop')
  var lang = require('../lib/lang')
  var TextHighlightRules = require('./text_highlight_rules').TextHighlightRules

  var ScssHighlightRules = function() {
    var properties = lang.arrayToMap((function() {
      var browserPrefix = ('-webkit-|-moz-|-o-|-ms-|-svg-|-pie-|-khtml-').split('|')

      var prefixProperties = ('appearance|background-clip|background-inline-policy|background-origin|' +
             'background-size|binding|border-bottom-colors|border-left-colors|' +
             'border-right-colors|border-top-colors|border-end|border-end-color|' +
             'border-end-style|border-end-width|border-image|border-start|' +
             'border-start-color|border-start-style|border-start-width|box-align|' +
             'box-direction|box-flex|box-flexgroup|box-ordinal-group|box-orient|' +
             'box-pack|box-sizing|column-count|column-gap|column-width|column-rule|' +
             'column-rule-width|column-rule-style|column-rule-color|float-edge|' +
             'font-feature-settings|font-language-override|force-broken-image-icon|' +
             'image-region|margin-end|margin-start|opacity|outline|outline-color|' +
             'outline-offset|outline-radius|outline-radius-bottomleft|' +
             'outline-radius-bottomright|outline-radius-topleft|outline-radius-topright|' +
             'outline-style|outline-width|padding-end|padding-start|stack-sizing|' +
             'tab-size|text-blink|text-decoration-color|text-decoration-line|' +
             'text-decoration-style|transform|transform-origin|transition|' +
             'transition-delay|transition-duration|transition-property|' +
             'transition-timing-function|user-focus|user-input|user-modify|user-select|' +
             'window-shadow|border-radius').split('|')

      var properties = ('azimuth|background-attachment|background-color|background-image|' +
            'background-position|background-repeat|background|border-bottom-color|' +
            'border-bottom-style|border-bottom-width|border-bottom|border-collapse|' +
            'border-color|border-left-color|border-left-style|border-left-width|' +
            'border-left|border-right-color|border-right-style|border-right-width|' +
            'border-right|border-spacing|border-style|border-top-color|' +
            'border-top-style|border-top-width|border-top|border-width|border|bottom|' +
            'box-shadow|box-sizing|caption-side|clear|clip|color|content|counter-increment|' +
            'counter-reset|cue-after|cue-before|cue|cursor|direction|display|' +
            'elevation|empty-cells|float|font-family|font-size-adjust|font-size|' +
            'font-stretch|font-style|font-variant|font-weight|font|height|left|' +
            'letter-spacing|line-height|list-style-image|list-style-position|' +
            'list-style-type|list-style|margin-bottom|margin-left|margin-right|' +
            'margin-top|marker-offset|margin|marks|max-height|max-width|min-height|' +
            'min-width|opacity|orphans|outline-color|' +
            'outline-style|outline-width|outline|overflow|overflow-x|overflow-y|padding-bottom|' +
            'padding-left|padding-right|padding-top|padding|page-break-after|' +
            'page-break-before|page-break-inside|page|pause-after|pause-before|' +
            'pause|pitch-range|pitch|play-during|position|quotes|richness|right|' +
            'size|speak-header|speak-numeral|speak-punctuation|speech-rate|speak|' +
            'stress|table-layout|text-align|text-decoration|text-indent|' +
            'text-shadow|text-transform|top|unicode-bidi|vertical-align|' +
            'visibility|voice-family|volume|white-space|widows|width|word-spacing|' +
            'z-index').split('|')
      var ret = []
      for (var i = 0, ln = browserPrefix.length; i < ln; i++) {
        Array.prototype.push.apply(
          ret,
          ((browserPrefix[i] + prefixProperties.join('|' + browserPrefix[i])).split('|'))
        )
      }
      Array.prototype.push.apply(ret, prefixProperties)
      Array.prototype.push.apply(ret, properties)

      return ret
    })())

    var functions = lang.arrayToMap(
      ('hsl|hsla|rgb|rgba|url|attr|counter|counters|abs|adjust_color|adjust_hue|' +
         'alpha|join|blue|ceil|change_color|comparable|complement|darken|desaturate|' +
         'floor|grayscale|green|hue|if|invert|join|length|lighten|lightness|mix|' +
         'nth|opacify|opacity|percentage|quote|red|round|saturate|saturation|' +
         'scale_color|transparentize|type_of|unit|unitless|unquote').split('|')
    )

    var constants = lang.arrayToMap(
      ('absolute|all-scroll|always|armenian|auto|baseline|below|bidi-override|' +
        'block|bold|bolder|border-box|both|bottom|break-all|break-word|capitalize|center|' +
        'char|circle|cjk-ideographic|col-resize|collapse|content-box|crosshair|dashed|' +
        'decimal-leading-zero|decimal|default|disabled|disc|' +
        'distribute-all-lines|distribute-letter|distribute-space|' +
        'distribute|dotted|double|e-resize|ellipsis|fixed|georgian|groove|' +
        'hand|hebrew|help|hidden|hiragana-iroha|hiragana|horizontal|' +
        'ideograph-alpha|ideograph-numeric|ideograph-parenthesis|' +
        'ideograph-space|inactive|inherit|inline-block|inline|inset|inside|' +
        'inter-ideograph|inter-word|italic|justify|katakana-iroha|katakana|' +
        'keep-all|left|lighter|line-edge|line-through|line|list-item|loose|' +
        'lower-alpha|lower-greek|lower-latin|lower-roman|lowercase|lr-tb|ltr|' +
        'medium|middle|move|n-resize|ne-resize|newspaper|no-drop|no-repeat|' +
        'nw-resize|none|normal|not-allowed|nowrap|oblique|outset|outside|' +
        'overline|pointer|progress|relative|repeat-x|repeat-y|repeat|right|' +
        'ridge|row-resize|rtl|s-resize|scroll|se-resize|separate|small-caps|' +
        'solid|square|static|strict|super|sw-resize|table-footer-group|' +
        'table-header-group|tb-rl|text-bottom|text-top|text|thick|thin|top|' +
        'transparent|underline|upper-alpha|upper-latin|upper-roman|uppercase|' +
        'vertical-ideographic|vertical-text|visible|w-resize|wait|whitespace|' +
        'zero').split('|')
    )

    var colors = lang.arrayToMap(
      ('aliceblue|antiquewhite|aqua|aquamarine|azure|beige|bisque|black|' +
        'blanchedalmond|blue|blueviolet|brown|burlywood|cadetblue|' +
        'chartreuse|chocolate|coral|cornflowerblue|cornsilk|crimson|cyan|' +
        'darkblue|darkcyan|darkgoldenrod|darkgray|darkgreen|darkgrey|' +
        'darkkhaki|darkmagenta|darkolivegreen|darkorange|darkorchid|darkred|' +
        'darksalmon|darkseagreen|darkslateblue|darkslategray|darkslategrey|' +
        'darkturquoise|darkviolet|deeppink|deepskyblue|dimgray|dimgrey|' +
        'dodgerblue|firebrick|floralwhite|forestgreen|fuchsia|gainsboro|' +
        'ghostwhite|gold|goldenrod|gray|green|greenyellow|grey|honeydew|' +
        'hotpink|indianred|indigo|ivory|khaki|lavender|lavenderblush|' +
        'lawngreen|lemonchiffon|lightblue|lightcoral|lightcyan|' +
        'lightgoldenrodyellow|lightgray|lightgreen|lightgrey|lightpink|' +
        'lightsalmon|lightseagreen|lightskyblue|lightslategray|' +
        'lightslategrey|lightsteelblue|lightyellow|lime|limegreen|linen|' +
        'magenta|maroon|mediumaquamarine|mediumblue|mediumorchid|' +
        'mediumpurple|mediumseagreen|mediumslateblue|mediumspringgreen|' +
        'mediumturquoise|mediumvioletred|midnightblue|mintcream|mistyrose|' +
        'moccasin|navajowhite|navy|oldlace|olive|olivedrab|orange|orangered|' +
        'orchid|palegoldenrod|palegreen|paleturquoise|palevioletred|' +
        'papayawhip|peachpuff|peru|pink|plum|powderblue|purple|rebeccapurple|' +
        'red|rosybrown|royalblue|saddlebrown|salmon|sandybrown|seagreen|' +
        'seashell|sienna|silver|skyblue|slateblue|slategray|slategrey|snow|' +
        'springgreen|steelblue|tan|teal|thistle|tomato|turquoise|violet|' +
        'wheat|white|whitesmoke|yellow|yellowgreen').split('|')
    )

    var keywords = lang.arrayToMap(
      ('@mixin|@extend|@include|@import|@media|@debug|@warn|@if|@for|@each|@while|@else|@font-face|@-webkit-keyframes|if|and|!default|module|def|end|declare').split('|')
    )

    var tags = lang.arrayToMap(
      ('a|abbr|acronym|address|applet|area|article|aside|audio|b|base|basefont|bdo|' +
         'big|blockquote|body|br|button|canvas|caption|center|cite|code|col|colgroup|' +
         'command|datalist|dd|del|details|dfn|dir|div|dl|dt|em|embed|fieldset|' +
         'figcaption|figure|font|footer|form|frame|frameset|h1|h2|h3|h4|h5|h6|head|' +
         'header|hgroup|hr|html|i|iframe|img|input|ins|keygen|kbd|label|legend|li|' +
         'link|map|mark|menu|meta|meter|nav|noframes|noscript|object|ol|optgroup|' +
         'option|output|p|param|pre|progress|q|rp|rt|ruby|s|samp|script|section|select|' +
         'small|source|span|strike|strong|style|sub|summary|sup|table|tbody|td|' +
         'textarea|tfoot|th|thead|time|title|tr|tt|u|ul|var|video|wbr|xmp').split('|')
    )
    var numRe = '\\-?(?:(?:[0-9]+)|(?:[0-9]*\\.[0-9]+))'
    this.$rules = {
      'start': [
        {
          token: 'comment',
          regex: '\\/\\/.*$'
        },
        {
          token: 'comment', // multi line comment
          regex: '\\/\\*',
          next: 'comment'
        }, {
          token: 'string', // single line
          regex: '["](?:(?:\\\\.)|(?:[^"\\\\]))*?["]'
        }, {
          token: 'string', // multi line string start
          regex: '["].*\\\\$',
          next: 'qqstring'
        }, {
          token: 'string', // single line
          regex: "['](?:(?:\\\\.)|(?:[^'\\\\]))*?[']"
        }, {
          token: 'string', // multi line string start
          regex: "['].*\\\\$",
          next: 'qstring'
        }, {
          token: 'constant.numeric',
          regex: numRe + '(?:em|ex|px|cm|mm|in|pt|pc|deg|rad|grad|ms|s|hz|khz|%)'
        }, {
          token: 'constant.numeric', // hex6 color
          regex: '#[a-f0-9]{6}'
        }, {
          token: 'constant.numeric', // hex3 color
          regex: '#[a-f0-9]{3}'
        }, {
          token: 'constant.numeric',
          regex: numRe
        }, {
          token: ['support.function', 'string', 'support.function'],
          regex: '(url\\()(.*)(\\))'
        }, {
          token: function(value) {
            if (properties.hasOwnProperty(value.toLowerCase())) { return 'support.type' }
            if (keywords.hasOwnProperty(value)) { return 'keyword' } else if (constants.hasOwnProperty(value)) { return 'constant.language' } else if (functions.hasOwnProperty(value)) { return 'support.function' } else if (colors.hasOwnProperty(value.toLowerCase())) { return 'support.constant.color' } else if (tags.hasOwnProperty(value.toLowerCase())) { return 'variable.language' } else { return 'text' }
          },
          regex: '\\-?[@a-z_][@a-z0-9_\\-]*'
        }, {
          token: 'variable',
          regex: '[a-z_\\-$][a-z0-9_\\-$]*\\b'
        }, {
          token: 'variable.language',
          regex: '#[a-z0-9-_]+'
        }, {
          token: 'variable.language',
          regex: '\\.[a-z0-9-_]+'
        }, {
          token: 'variable.language',
          regex: ':[a-z0-9-_]+'
        }, {
          token: 'constant',
          regex: '[a-z0-9-_]+'
        }, {
          token: 'keyword.operator',
          regex: '<|>|<=|>=|==|!=|-|%|#|\\+|\\$|\\+|\\*'
        }, {
          token: 'paren.lparen',
          regex: '[[({]'
        }, {
          token: 'paren.rparen',
          regex: '[\\])}]'
        }, {
          token: 'text',
          regex: '\\s+'
        }, {
          caseInsensitive: true
        }
      ],
      'comment': [
        {
          token: 'comment', // closing comment
          regex: '\\*\\/',
          next: 'start'
        }, {
          defaultToken: 'comment'
        }
      ],
      'qqstring': [
        {
          token: 'string',
          regex: '(?:(?:\\\\.)|(?:[^"\\\\]))*?"',
          next: 'start'
        }, {
          token: 'string',
          regex: '.+'
        }
      ],
      'qstring': [
        {
          token: 'string',
          regex: "(?:(?:\\\\.)|(?:[^'\\\\]))*?'",
          next: 'start'
        }, {
          token: 'string',
          regex: '.+'
        }
      ]
    }
  }

  oop.inherits(ScssHighlightRules, TextHighlightRules)

  exports.ScssHighlightRules = ScssHighlightRules
})

define('ace/mode/matching_brace_outdent', ['require', 'exports', 'module', 'ace/range'], function(require, exports, module) {
  'use strict'

  var Range = require('../range').Range

  var MatchingBraceOutdent = function() {};

  (function() {
    this.checkOutdent = function(line, input) {
      if (!/^\s+$/.test(line)) { return false }

      return /^\s*\}/.test(input)
    }

    this.autoOutdent = function(doc, row) {
      var line = doc.getLine(row)
      var match = line.match(/^(\s*\})/)

      if (!match) return 0

      var column = match[1].length
      var openBracePos = doc.findMatchingBracket({ row: row, column: column })

      if (!openBracePos || openBracePos.row == row) return 0

      var indent = this.$getIndent(doc.getLine(openBracePos.row))
      doc.replace(new Range(row, 0, row, column - 1), indent)
    }

    this.$getIndent = function(line) {
      return line.match(/^\s*/)[0]
    }
  }).call(MatchingBraceOutdent.prototype)

  exports.MatchingBraceOutdent = MatchingBraceOutdent
})

define('ace/mode/behaviour/css', ['require', 'exports', 'module', 'ace/lib/oop', 'ace/mode/behaviour', 'ace/mode/behaviour/cstyle', 'ace/token_iterator'], function(require, exports, module) {
  'use strict'

  var oop = require('../../lib/oop')
  var Behaviour = require('../behaviour').Behaviour
  var CstyleBehaviour = require('./cstyle').CstyleBehaviour
  var TokenIterator = require('../../token_iterator').TokenIterator

  var CssBehaviour = function() {
    this.inherit(CstyleBehaviour)

    this.add('colon', 'insertion', function(state, action, editor, session, text) {
      if (text === ':' && editor.selection.isEmpty()) {
        var cursor = editor.getCursorPosition()
        var iterator = new TokenIterator(session, cursor.row, cursor.column)
        var token = iterator.getCurrentToken()
        if (token && token.value.match(/\s+/)) {
          token = iterator.stepBackward()
        }
        if (token && token.type === 'support.type') {
          var line = session.doc.getLine(cursor.row)
          var rightChar = line.substring(cursor.column, cursor.column + 1)
          if (rightChar === ':') {
            return {
              text: '',
              selection: [1, 1]
            }
          }
          if (/^(\s+[^;]|\s*$)/.test(line.substring(cursor.column))) {
            return {
              text: ':;',
              selection: [1, 1]
            }
          }
        }
      }
    })

    this.add('colon', 'deletion', function(state, action, editor, session, range) {
      var selected = session.doc.getTextRange(range)
      if (!range.isMultiLine() && selected === ':') {
        var cursor = editor.getCursorPosition()
        var iterator = new TokenIterator(session, cursor.row, cursor.column)
        var token = iterator.getCurrentToken()
        if (token && token.value.match(/\s+/)) {
          token = iterator.stepBackward()
        }
        if (token && token.type === 'support.type') {
          var line = session.doc.getLine(range.start.row)
          var rightChar = line.substring(range.end.column, range.end.column + 1)
          if (rightChar === ';') {
            range.end.column++
            return range
          }
        }
      }
    })

    this.add('semicolon', 'insertion', function(state, action, editor, session, text) {
      if (text === ';' && editor.selection.isEmpty()) {
        var cursor = editor.getCursorPosition()
        var line = session.doc.getLine(cursor.row)
        var rightChar = line.substring(cursor.column, cursor.column + 1)
        if (rightChar === ';') {
          return {
            text: '',
            selection: [1, 1]
          }
        }
      }
    })

    this.add('!important', 'insertion', function(state, action, editor, session, text) {
      if (text === '!' && editor.selection.isEmpty()) {
        var cursor = editor.getCursorPosition()
        var line = session.doc.getLine(cursor.row)

        if (/^\s*(;|}|$)/.test(line.substring(cursor.column))) {
          return {
            text: '!important',
            selection: [10, 10]
          }
        }
      }
    })
  }
  oop.inherits(CssBehaviour, CstyleBehaviour)

  exports.CssBehaviour = CssBehaviour
})

define('ace/mode/folding/cstyle', ['require', 'exports', 'module', 'ace/lib/oop', 'ace/range', 'ace/mode/folding/fold_mode'], function(require, exports, module) {
  'use strict'

  var oop = require('../../lib/oop')
  var Range = require('../../range').Range
  var BaseFoldMode = require('./fold_mode').FoldMode

  var FoldMode = exports.FoldMode = function(commentRegex) {
    if (commentRegex) {
      this.foldingStartMarker = new RegExp(
        this.foldingStartMarker.source.replace(/\|[^|]*?$/, '|' + commentRegex.start)
      )
      this.foldingStopMarker = new RegExp(
        this.foldingStopMarker.source.replace(/\|[^|]*?$/, '|' + commentRegex.end)
      )
    }
  }
  oop.inherits(FoldMode, BaseFoldMode);

  (function() {
    this.foldingStartMarker = /([\{\[\(])[^\}\]\)]*$|^\s*(\/\*)/
    this.foldingStopMarker = /^[^\[\{\(]*([\}\]\)])|^[\s\*]*(\*\/)/
    this.singleLineBlockCommentRe = /^\s*(\/\*).*\*\/\s*$/
    this.tripleStarBlockCommentRe = /^\s*(\/\*\*\*).*\*\/\s*$/
    this.startRegionRe = /^\s*(\/\*|\/\/)#?region\b/
    this._getFoldWidgetBase = this.getFoldWidget
    this.getFoldWidget = function(session, foldStyle, row) {
      var line = session.getLine(row)

      if (this.singleLineBlockCommentRe.test(line)) {
        if (!this.startRegionRe.test(line) && !this.tripleStarBlockCommentRe.test(line)) { return '' }
      }

      var fw = this._getFoldWidgetBase(session, foldStyle, row)

      if (!fw && this.startRegionRe.test(line)) { return 'start' } // lineCommentRegionStart

      return fw
    }

    this.getFoldWidgetRange = function(session, foldStyle, row, forceMultiline) {
      var line = session.getLine(row)

      if (this.startRegionRe.test(line)) { return this.getCommentRegionBlock(session, line, row) }

      var match = line.match(this.foldingStartMarker)
      if (match) {
        var i = match.index

        if (match[1]) { return this.openingBracketBlock(session, match[1], row, i) }

        var range = session.getCommentFoldRange(row, i + match[0].length, 1)

        if (range && !range.isMultiLine()) {
          if (forceMultiline) {
            range = this.getSectionRange(session, row)
          } else if (foldStyle != 'all') { range = null }
        }

        return range
      }

      if (foldStyle === 'markbegin') { return }

      var match = line.match(this.foldingStopMarker)
      if (match) {
        var i = match.index + match[0].length

        if (match[1]) { return this.closingBracketBlock(session, match[1], row, i) }

        return session.getCommentFoldRange(row, i, -1)
      }
    }

    this.getSectionRange = function(session, row) {
      var line = session.getLine(row)
      var startIndent = line.search(/\S/)
      var startRow = row
      var startColumn = line.length
      row = row + 1
      var endRow = row
      var maxRow = session.getLength()
      while (++row < maxRow) {
        line = session.getLine(row)
        var indent = line.search(/\S/)
        if (indent === -1) { continue }
        if (startIndent > indent) { break }
        var subRange = this.getFoldWidgetRange(session, 'all', row)

        if (subRange) {
          if (subRange.start.row <= startRow) {
            break
          } else if (subRange.isMultiLine()) {
            row = subRange.end.row
          } else if (startIndent == indent) {
            break
          }
        }
        endRow = row
      }

      return new Range(startRow, startColumn, endRow, session.getLine(endRow).length)
    }
    this.getCommentRegionBlock = function(session, line, row) {
      var startColumn = line.search(/\s*$/)
      var maxRow = session.getLength()
      var startRow = row

      var re = /^\s*(?:\/\*|\/\/|--)#?(end)?region\b/
      var depth = 1
      while (++row < maxRow) {
        line = session.getLine(row)
        var m = re.exec(line)
        if (!m) continue
        if (m[1]) depth--
        else depth++

        if (!depth) break
      }

      var endRow = row
      if (endRow > startRow) {
        return new Range(startRow, startColumn, endRow, line.length)
      }
    }
  }).call(FoldMode.prototype)
})

define('ace/mode/scss', ['require', 'exports', 'module', 'ace/lib/oop', 'ace/mode/text', 'ace/mode/scss_highlight_rules', 'ace/mode/matching_brace_outdent', 'ace/mode/behaviour/css', 'ace/mode/folding/cstyle'], function(require, exports, module) {
  'use strict'

  var oop = require('../lib/oop')
  var TextMode = require('./text').Mode
  var ScssHighlightRules = require('./scss_highlight_rules').ScssHighlightRules
  var MatchingBraceOutdent = require('./matching_brace_outdent').MatchingBraceOutdent
  var CssBehaviour = require('./behaviour/css').CssBehaviour
  var CStyleFoldMode = require('./folding/cstyle').FoldMode

  var Mode = function() {
    this.HighlightRules = ScssHighlightRules
    this.$outdent = new MatchingBraceOutdent()
    this.$behaviour = new CssBehaviour()
    this.foldingRules = new CStyleFoldMode()
  }
  oop.inherits(Mode, TextMode);

  (function() {
    this.lineCommentStart = '//'
    this.blockComment = { start: '/*', end: '*/' }

    this.getNextLineIndent = function(state, line, tab) {
      var indent = this.$getIndent(line)
      var tokens = this.getTokenizer().getLineTokens(line, state).tokens
      if (tokens.length && tokens[tokens.length - 1].type == 'comment') {
        return indent
      }

      var match = line.match(/^.*\{\s*$/)
      if (match) {
        indent += tab
      }

      return indent
    }

    this.checkOutdent = function(state, line, input) {
      return this.$outdent.checkOutdent(line, input)
    }

    this.autoOutdent = function(state, doc, row) {
      this.$outdent.autoOutdent(doc, row)
    }

    this.$id = 'ace/mode/scss'
  }).call(Mode.prototype)

  exports.Mode = Mode
});
(function() {
  window.require(['ace/mode/scss'], function(m) {
    if (typeof module === 'object' && typeof exports === 'object' && module) {
      module.exports = m
    }
  })
})()
